[TIMING:end] tool::ToolBuild { build_compiler: Compiler { stage: 0, host: x86_64-unknown-linux-gnu, forced_compiler: false }, target: x86_64-unknown-linux-gnu, tool: "tidy", path: "src/tools/tidy", mode: ToolBootstrap, source_type: InTree, extra_features: [], allow_features: "", cargo_args: [], artifact_kind: Binary } -- 11.569
[TIMING:end] tool::Tidy { compiler: Compiler { stage: 0, host: x86_64-unknown-linux-gnu, forced_compiler: false }, target: x86_64-unknown-linux-gnu } -- 0.000
fmt check
Diff in /checkout/compiler/rustc_hir_typeck/src/coercion.rs:854:
                 let a = Ty::new_fn_ptr(self.tcx, a_sig);
 
                 let adjust = Adjust::Pointer(PointerCoercion::ReifyFnPointer);
-                let (a, opt_adjustment, adjust) = if a_sig.safety().is_safe() && b_hdr.safety.is_unsafe() {
-                    let unsafe_a = self.tcx.safe_to_unsafe_fn_ty(a_sig);
-                    (unsafe_a, Some(Adjustment { kind: adjust, target: a }), Adjust::Pointer(PointerCoercion::UnsafeFnPointer))
-                } else {
-                    (a, None, adjust)
-                };
-                let InferOk { value, obligations: o2 } = self.unify_and(a, b, opt_adjustment, adjust)?;
+                let (a, opt_adjustment, adjust) =
+                    if a_sig.safety().is_safe() && b_hdr.safety.is_unsafe() {
+                        let unsafe_a = self.tcx.safe_to_unsafe_fn_ty(a_sig);
+                        (
+                            unsafe_a,
+                            Some(Adjustment { kind: adjust, target: a }),
+                            Adjust::Pointer(PointerCoercion::UnsafeFnPointer),
+                        )
+                    } else {
+                        (a, None, adjust)
+                    };
+                let InferOk { value, obligations: o2 } =
+                    self.unify_and(a, b, opt_adjustment, adjust)?;
 
                 obligations.extend(o2);
                 Ok(InferOk { value, obligations })
Diff in /checkout/compiler/rustc_hir_typeck/src/coercion.rs:1213:
             // Allow coercing safe sigs to unsafe sigs
             let mut adjust_a_safety = false;
             let mut adjust_b_safety = false;
-            
+
             if a_sig.safety().is_safe() && b_sig.safety().is_unsafe() {
                 a_sig = self.tcx.safe_to_unsafe_sig(a_sig);
                 adjust_a_safety = true;
Diff in /checkout/compiler/rustc_hir_typeck/src/coercion.rs:1250:
             let adjustments = |adjust_kind, should_adjust_safety| {
                 let mut adjustments = Vec::with_capacity(2);
 
-                let unadjusted_fn_ptr = if should_adjust_safety {
-                    safe_fn_ptr
-                } else {
-                    fn_ptr
-                };
+                let unadjusted_fn_ptr = if should_adjust_safety { safe_fn_ptr } else { fn_ptr };
 
-                adjustments.push(
-                    Adjustment { kind: adjust_kind, target: unadjusted_fn_ptr }
-                );
+                adjustments.push(Adjustment { kind: adjust_kind, target: unadjusted_fn_ptr });
                 if should_adjust_safety {
-                    adjustments.push(
-                        Adjustment { kind: Adjust::Pointer(PointerCoercion::UnsafeFnPointer), target: fn_ptr}
-                    )
+                    adjustments.push(Adjustment {
+                        kind: Adjust::Pointer(PointerCoercion::UnsafeFnPointer),
+                        target: fn_ptr,
+                    })
                 }
 
                 adjustments
Diff in /checkout/compiler/rustc_hir_typeck/src/coercion.rs:1269:
             };
-            
+
             for expr in exprs.iter().map(|e| e.as_coercion_site()) {
-                self.apply_adjustments(
-                    expr,
-                    adjustments(prev_adjustment.clone(), adjust_a_safety),
-                );
+                self.apply_adjustments(expr, adjustments(prev_adjustment.clone(), adjust_a_safety));
             }
             self.apply_adjustments(new, adjustments(next_adjustment, adjust_b_safety));
             return Ok(fn_ptr);
Diff in /checkout/compiler/rustc_borrowck/src/type_check/mod.rs:1062:
 
             Rvalue::Cast(cast_kind, op, ty) => {
                 match *cast_kind {
-                    CastKind::PointerCoercion(
-                        PointerCoercion::ReifyFnPointer,
-                        coercion_source,
-                    ) => {
+                    CastKind::PointerCoercion(PointerCoercion::ReifyFnPointer, coercion_source) => {
                         let is_implicit_coercion = coercion_source == CoercionSource::Implicit;
                         let src_ty = op.ty(self.body, tcx);
                         let mut src_sig = src_ty.fn_sig(tcx);
Diff in /checkout/compiler/rustc_middle/src/ty/context.rs:2854:
     /// that is, a `fn` sig that is equivalent in every way for being
     /// safe.
     pub fn unsafe_to_safe_sig(self, sig: PolyFnSig<'tcx>) -> PolyFnSig<'tcx> {
-        sig.map_bound(|sig| ty::FnSig{ safety: hir::Safety::Safe, ..sig  })
+        sig.map_bound(|sig| ty::FnSig { safety: hir::Safety::Safe, ..sig })
     }
 
     /// Given the def_id of a Trait `trait_def_id` and the name of an associated item `assoc_name`
fmt: checked 6519 files
Bootstrap failed while executing `test src/tools/tidy tidyselftest --extra-checks=py,cpp,js,spellcheck`